home *** CD-ROM | disk | FTP | other *** search
/ SGI Developer Toolbox 6.1 / SGI Developer Toolbox 6.1 - Disc 4.iso / public / pbmplus / pgm / pgmcrater.c < prev    next >
C/C++ Source or Header  |  1994-08-01  |  10KB  |  364 lines
  1. /*
  2.  
  3.               Fractal cratering
  4.  
  5.        Designed and implemented in November of 1989 by:
  6.  
  7.         John Walker
  8.         Autodesk SA
  9.         Avenue des Champs-Montants 14b
  10.         CH-2074 MARIN
  11.         Switzerland
  12.         Usenet: kelvin@Autodesk.com
  13.         Fax:    038/33 88 15
  14.         Voice:  038/33 76 33
  15.  
  16.     The  algorithm  used  to  determine crater size is as described on
  17.     pages 31 and 32 of:
  18.  
  19.     Peitgen, H.-O., and Saupe, D. eds., The Science Of Fractal
  20.         Images, New York: Springer Verlag, 1988.
  21.  
  22.     The  mathematical  technique  used    to calculate crater radii that
  23.     obey the proper area law distribution from a uniformly distributed
  24.     pseudorandom sequence was developed by Rudy Rucker.
  25.  
  26.     Permission    to  use, copy, modify, and distribute this software and
  27.     its documentation  for  any  purpose  and  without    fee  is  hereby
  28.     granted,  without any conditions or restrictions.  This software is
  29.     provided "as is" without express or implied warranty.
  30.  
  31.                 PLUGWARE!
  32.  
  33.     If you like this kind of stuff, you may also enjoy "James  Gleick's
  34.     Chaos--The  Software"  for  MS-DOS,  available for $59.95 from your
  35.     local software store or directly from Autodesk, Inc., Attn: Science
  36.     Series,  2320  Marinship Way, Sausalito, CA 94965, USA.  Telephone:
  37.     (800) 688-2344 toll-free or, outside the  U.S. (415)  332-2344  Ext
  38.     4886.   Fax: (415) 289-4718.  "Chaos--The Software" includes a more
  39.     comprehensive   fractal    forgery      generator    which    creates
  40.     three-dimensional  landscapes  as  well as clouds and planets, plus
  41.     five more modules which explore other aspects of Chaos.   The  user
  42.     guide  of  more  than  200    pages includes an introduction by James
  43.     Gleick and detailed explanations by Rudy Rucker of the  mathematics
  44.     and algorithms used by each program.
  45.  
  46. */
  47.  
  48. #include "pgm.h"
  49. #include <math.h>
  50.  
  51. /* Definitions for obtaining random numbers. */
  52.  
  53. #define Cast(low, high) ((low)+((high)-(low)) * ((random() & 0x7FFF) / arand))
  54.  
  55. /*  Data types    */
  56.  
  57. typedef int Boolean;
  58. #define FALSE 0
  59. #define TRUE 1
  60.  
  61. #define V   (void)
  62.  
  63. /*  Display parameters    */
  64.  
  65. #define SCRX    screenxsize          /* Screen width */
  66. #define SCRY    screenysize          /* Screen height */
  67. #define SCRGAMMA 1.0              /* Display gamma */
  68.  
  69. /*  Local variables  */
  70.  
  71. #define ImageGamma  0.5           /* Inherent gamma of mapped image */
  72.  
  73. static int screenxsize = 256;          /* Screen X size */
  74. static int screenysize = 256;          /* Screen Y size */
  75. static double dgamma = SCRGAMMA;      /* Display gamma */
  76. static double arand = 32767.0;          /* Random number parameters */
  77. static long ncraters = 50000L;          /* Number of craters to generate */
  78. static double CdepthPower = 1.5;      /* Crater depth power factor */
  79. static double DepthBias = 0.707107;   /* Depth bias */
  80.  
  81. /*  INITSEED  --  Generate initial random seed, if needed.  */
  82.  
  83. static void initseed()
  84. {
  85.     int i;
  86.  
  87.     i = time((long *) 0) * 0xF37C;
  88.     srandom(i);
  89.     for (i = 0; i < 7; i++) {
  90.     V random();
  91.     }
  92. }
  93.  
  94. /*  GENCRATERS    --  Generate cratered terrain.    */
  95.  
  96. static void gencraters()
  97. {
  98.     int i, j, x, y;
  99.     long l;
  100.     unsigned short *aux;
  101.     int slopemin = -52, slopemax = 52;
  102. #define RGBQuant    255
  103.     unsigned char *slopemap;   /* Slope to pixel map */
  104.     gray *pixels;           /* Pixel vector */
  105.  
  106. #define Auxadr(x, y)  ((unsigned short *) (aux + ((((y)) * SCRX) + (x))))
  107.  
  108.     /* Acquire the elevation array and initialise it to mean
  109.        surface elevation. */
  110.  
  111.     aux = (unsigned short *) malloc(SCRX * SCRY * sizeof(short));
  112.     if (aux == (unsigned short *) 0) {
  113.         pm_error("out of memory allocating elevation array");
  114.     }
  115.  
  116.     /* Acquire the elevation buffer and initialise to mean
  117.        initial elevation. */
  118.  
  119.     for (i = 0; i < SCRY; i++) {
  120.     unsigned short *zax = aux + (((long) SCRX) * i);
  121.  
  122.     for (j = 0; j < SCRX; j++) {
  123.         *zax++ = 32767;
  124.     }
  125.     }
  126.  
  127.     /* Every time we go around this loop we plop another crater
  128.        on the surface.    */
  129.  
  130.     for (l = 0; l < ncraters; l++) {
  131.     double g;
  132.     int cx = Cast(0.0, ((double) SCRX - 1)),
  133.         cy = Cast(0.0, ((double) SCRY - 1)),
  134.         gx, gy, x, y;
  135.     unsigned long amptot = 0, axelev;
  136.     unsigned int npatch = 0;
  137.  
  138.  
  139.     /* Phase 1.  Compute the mean elevation of the impact
  140.              area.  We assume the impact area is a
  141.              fraction of the total crater size. */
  142.  
  143.     /* Thanks, Rudy, for this equation  that maps the uniformly
  144.        distributed    numbers  from    Cast   into   an   area-law
  145.        distribution as observed on cratered bodies. */
  146.  
  147.     g = sqrt(1 / (M_PI * (1 - Cast(0, 0.9999))));
  148.  
  149.     /* If the crater is tiny, handle it specially. */
  150.  
  151.     if (g < 3) {
  152.  
  153.        /* Set pixel to the average of its Moore neighbourhood. */
  154.  
  155.         for (y = max(0, cy - 1); y <= min(SCRY - 1, cy + 1); y++) {
  156.         int sx = max(0, cx - 1);
  157.         unsigned short *a = Auxadr(sx, y);
  158.  
  159.         for (x = sx; x <= min(SCRX - 1, cx + 1); x++) {
  160.             amptot += *a++;
  161.             npatch++;
  162.         }
  163.         }
  164.         axelev = amptot / npatch;
  165.  
  166.         /* Perturb the mean elevation by a small random factor. */
  167.  
  168.         x = (g >= 1) ? ((random() >> 8) & 3) - 1 : 0;
  169.         *Auxadr(cx, cy) = axelev + x;
  170.  
  171.         /* Jam repaint sizes to correct patch. */
  172.  
  173.         gx = 1;
  174.         gy = 0;
  175.  
  176.     } else {
  177.  
  178.         /* Regular crater.    Generate an impact feature of the
  179.            correct size and shape. */
  180.  
  181.         /* Determine mean elevation around the impact area. */
  182.  
  183.         gx = max(2, (g / 3));
  184.         gy = max(2, g / 3);
  185.  
  186.         for (y = max(0, cy - gy); y <= min(SCRY - 1, cy + gy); y++) {
  187.         int sx = max(0, cx - gx);
  188.         unsigned short *a = Auxadr(sx, y);
  189.  
  190.         for (x = sx; x <= min(SCRX - 1, cx + gx); x++) {
  191.             amptot += *a++;
  192.             npatch++;
  193.         }
  194.         }
  195.         axelev = amptot / npatch;
  196.  
  197.         gy = max(2, g);
  198.         g = gy;
  199.         gx = max(2, g);
  200.  
  201.         for (y = max(0, cy - gy); y <= min(SCRY - 1, cy + gy); y++) {
  202.         int sx = max(0, cx - gx);
  203.         unsigned short *ax = Auxadr(sx, y);
  204.         double dy = (cy - y) / (double) gy,
  205.                dysq = dy * dy;
  206.  
  207.         for (x = sx; x <= min(SCRX - 1, cx + gx); x++) {
  208.             double dx = ((cx - x) / (double) gx),
  209.                cd = (dx * dx) + dysq,
  210.                cd2 = cd * 2.25,
  211.                tcz = DepthBias - sqrt(fabs(1 - cd2)),
  212.                cz = max((cd2 > 1) ? 0.0 : -10, tcz),
  213.                roll, iroll;
  214.             unsigned short av;
  215.  
  216.             cz *= pow(g, CdepthPower);
  217.             if (dy == 0 && dx == 0 && ((int) cz) == 0) {
  218.                cz = cz < 0 ? -1 : 1;
  219.             }
  220.  
  221. #define         rollmin 0.9
  222.             roll = (((1 / (1 - min(rollmin, cd))) /
  223.                  (1 / (1 - rollmin))) - (1 - rollmin)) / rollmin;
  224.             iroll = 1 - roll;
  225.  
  226.             av = (axelev + cz) * iroll + (*ax + cz) * roll;
  227.             av = max(1000, min(64000, av));
  228.             *ax++ = av;
  229.         }
  230.         }
  231.      }
  232.     if ((l % 5000) == 4999) {
  233.         pm_message( "%ld craters generated of %ld (%ld%% done)",
  234.         l + 1, ncraters, ((l + 1) * 100) / ncraters);
  235.     }
  236.     }
  237.  
  238.     i = max((slopemax - slopemin) + 1, 1);
  239.     slopemap = (unsigned char *) malloc(i * sizeof(unsigned char));
  240.     if (slopemap == (unsigned char *) 0) {
  241.         pm_error("out of memory allocating slope map");
  242.     }
  243.     for (i = slopemin; i <= slopemax; i++) {
  244.  
  245.         /* Confused?   OK,  we're using the  left-to-right slope to
  246.        calculate a shade based on the sine of  the    angle  with
  247.        respect  to the vertical (light incident from the left).
  248.        Then, with one exponentiation, we account for  both    the
  249.        inherent   gamma   of   the     image    (ad-hoc),  and    the
  250.        user-specified display gamma, using the identity:
  251.  
  252.          (x^y)^z = (x^(y*z))             */
  253.  
  254.     slopemap[i - slopemin] = i > 0 ?
  255.         (128 + 127.0 *
  256.         pow(sin((M_PI / 2) * i / slopemax),
  257.                dgamma * ImageGamma)) :
  258.         (128 - 127.0 *
  259.         pow(sin((M_PI / 2) * i / slopemin),
  260.                dgamma * ImageGamma));
  261.     }
  262.  
  263.     /* Generate the screen image. */
  264.  
  265.     pgm_writepgminit(stdout, SCRX, SCRY, RGBQuant, FALSE);
  266.     pixels = pgm_allocrow(SCRX);
  267.  
  268.     for (y = 0; y < SCRY; y++) {
  269.     unsigned short *ax = Auxadr(0, y);
  270.     gray *pix = pixels;
  271.  
  272.     for (x = 0; x < SCRX - 1; x++) {
  273.         int j = ax[1] - ax[0];
  274.         j = min(max(slopemin, j), slopemax);
  275.         *pix++ = slopemap[j - slopemin];
  276.         ax++;
  277.     }
  278.     pgm_writepgmrow(stdout, pixels, SCRX, RGBQuant, FALSE);
  279.     }
  280.     pm_close(stdout);
  281.     pgm_freerow(pixels);
  282.  
  283. #undef Auxadr
  284. #undef Scradr
  285.     free((char *) slopemap);
  286.     free((char *) aux);
  287. }
  288.  
  289. /*  MAIN  --  Main program.  */
  290.  
  291. int main(argc, argv)
  292.   int argc;
  293.   char *argv[];
  294. {
  295.     int i;
  296.     Boolean gammaspec = FALSE, numspec = FALSE,
  297.         widspec = FALSE, hgtspec = FALSE;
  298.     char *usage = "[-number <n>] [-width|-xsize <w>]\n\
  299.                   [-height|-ysize <h>] [-gamma <f>]";
  300.  
  301.     DepthBias = sqrt(0.5);          /* Get exact value for depth bias */
  302.  
  303.     pgm_init(&argc, argv);
  304.  
  305.     i = 1;
  306.     while ((i < argc) && (argv[i][0] == '-') && (argv[i][1] != '\0')) {
  307.         if (pm_keymatch(argv[i], "-gamma", 2)) {
  308.         if (gammaspec) {
  309.                 pm_error("already specified gamma correction");
  310.         }
  311.         i++;
  312.             if ((i == argc) || (sscanf(argv[i], "%lf", &dgamma)  != 1))
  313.         pm_usage(usage);
  314.         if (dgamma <= 0.0) {
  315.                 pm_error("gamma correction must be greater than 0");
  316.         }
  317.         gammaspec = TRUE;
  318.         } else if (pm_keymatch(argv[i], "-number", 2)) {
  319.         if (numspec) {
  320.                 pm_error("already specified number of craters");
  321.         }
  322.         i++;
  323.             if ((i == argc) || (sscanf(argv[i], "%ld", &ncraters) != 1))
  324.         pm_usage(usage);
  325.         if (ncraters <= 0) {
  326.                 pm_error("number of craters must be greater than 0!");
  327.         }
  328.         numspec = TRUE;
  329.         } else if (pm_keymatch(argv[i], "-xsize", 2) ||
  330.                    pm_keymatch(argv[i], "-width", 2)) {
  331.         if (widspec) {
  332.                 pm_error("already specified a width/xsize");
  333.         }
  334.         i++;
  335.             if ((i == argc) || (sscanf(argv[i], "%d", &screenxsize) != 1))
  336.         pm_usage(usage);
  337.         if (screenxsize <= 0) {
  338.                 pm_error("screen width must be greater than 0");
  339.         }
  340.         widspec = TRUE;
  341.         } else if (pm_keymatch(argv[i], "-ysize", 2) ||
  342.                    pm_keymatch(argv[i], "-height", 2)) {
  343.         if (hgtspec) {
  344.                 pm_error("already specified a height/ysize");
  345.         }
  346.         i++;
  347.             if ((i == argc) || (sscanf(argv[i], "%d", &screenysize) != 1))
  348.         pm_usage(usage);
  349.         if (screenxsize <= 0) {
  350.                 pm_error("screen height must be greater than 0");
  351.         }
  352.         hgtspec = TRUE;
  353.     } else {
  354.         pm_usage(usage);
  355.     }
  356.     i++;
  357.     }
  358.  
  359.     initseed();
  360.     gencraters();
  361.  
  362.     exit(0);
  363. }
  364.